home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / perl5 / IO / Compress / Zip.pm < prev   
Encoding:
Perl POD Document  |  2008-09-03  |  41.3 KB  |  1,513 lines
  1. package IO::Compress::Zip ;
  2.  
  3. use strict ;
  4. use warnings;
  5. use bytes;
  6.  
  7. use IO::Compress::Base::Common  2.015 qw(:Status createSelfTiedObject);
  8. use IO::Compress::RawDeflate 2.015 ;
  9. use IO::Compress::Adapter::Deflate 2.015 ;
  10. use IO::Compress::Adapter::Identity 2.015 ;
  11. use IO::Compress::Zlib::Extra 2.015 ;
  12. use IO::Compress::Zip::Constants 2.015 ;
  13.  
  14.  
  15. use Compress::Raw::Zlib  2.015 qw(crc32) ;
  16. BEGIN
  17. {
  18.     eval { require IO::Compress::Adapter::Bzip2 ; 
  19.            import  IO::Compress::Adapter::Bzip2 2.015 ; 
  20.            require IO::Compress::Bzip2 ; 
  21.            import  IO::Compress::Bzip2 2.015 ; 
  22.          } ;
  23. }
  24.  
  25.  
  26. require Exporter ;
  27.  
  28. our ($VERSION, @ISA, @EXPORT_OK, %EXPORT_TAGS, $ZipError);
  29.  
  30. $VERSION = '2.015';
  31. $ZipError = '';
  32.  
  33. @ISA = qw(Exporter IO::Compress::RawDeflate);
  34. @EXPORT_OK = qw( $ZipError zip ) ;
  35. %EXPORT_TAGS = %IO::Compress::RawDeflate::DEFLATE_CONSTANTS ;
  36. push @{ $EXPORT_TAGS{all} }, @EXPORT_OK ;
  37.  
  38. $EXPORT_TAGS{zip_method} = [qw( ZIP_CM_STORE ZIP_CM_DEFLATE ZIP_CM_BZIP2 )];
  39. push @{ $EXPORT_TAGS{all} }, @{ $EXPORT_TAGS{zip_method} };
  40.  
  41. Exporter::export_ok_tags('all');
  42.  
  43. sub new
  44. {
  45.     my $class = shift ;
  46.  
  47.     my $obj = createSelfTiedObject($class, \$ZipError);    
  48.     $obj->_create(undef, @_);
  49. }
  50.  
  51. sub zip
  52. {
  53.     my $obj = createSelfTiedObject(undef, \$ZipError);    
  54.     return $obj->_def(@_);
  55. }
  56.  
  57. sub mkComp
  58. {
  59.     my $self = shift ;
  60.     my $got = shift ;
  61.  
  62.     my ($obj, $errstr, $errno) ;
  63.  
  64.     if (*$self->{ZipData}{Method} == ZIP_CM_STORE) {
  65.         ($obj, $errstr, $errno) = IO::Compress::Adapter::Identity::mkCompObject(
  66.                                                  $got->value('Level'),
  67.                                                  $got->value('Strategy')
  68.                                                  );
  69.     }
  70.     elsif (*$self->{ZipData}{Method} == ZIP_CM_DEFLATE) {
  71.         ($obj, $errstr, $errno) = IO::Compress::Adapter::Deflate::mkCompObject(
  72.                                                  $got->value('CRC32'),
  73.                                                  $got->value('Adler32'),
  74.                                                  $got->value('Level'),
  75.                                                  $got->value('Strategy')
  76.                                                  );
  77.     }
  78.     elsif (*$self->{ZipData}{Method} == ZIP_CM_BZIP2) {
  79.         ($obj, $errstr, $errno) = IO::Compress::Adapter::Bzip2::mkCompObject(
  80.                                                 $got->value('BlockSize100K'),
  81.                                                 $got->value('WorkFactor'),
  82.                                                 $got->value('Verbosity')
  83.                                                );
  84.         *$self->{ZipData}{CRC32} = crc32(undef);
  85.     }
  86.  
  87.     return $self->saveErrorString(undef, $errstr, $errno)
  88.        if ! defined $obj;
  89.  
  90.     if (! defined *$self->{ZipData}{StartOffset}) {
  91.         *$self->{ZipData}{StartOffset} = 0;
  92.         *$self->{ZipData}{Offset} = new U64 ;
  93.     }
  94.  
  95.     return $obj;    
  96. }
  97.  
  98. sub reset
  99. {
  100.     my $self = shift ;
  101.  
  102.     *$self->{Compress}->reset();
  103.     *$self->{ZipData}{CRC32} = Compress::Raw::Zlib::crc32('');
  104.  
  105.     return STATUS_OK;    
  106. }
  107.  
  108. sub filterUncompressed
  109. {
  110.     my $self = shift ;
  111.  
  112.     if (*$self->{ZipData}{Method} == ZIP_CM_DEFLATE) {
  113.         *$self->{ZipData}{CRC32} = *$self->{Compress}->crc32();
  114.     }
  115.     else {
  116.         *$self->{ZipData}{CRC32} = crc32(${$_[0]}, *$self->{ZipData}{CRC32});
  117.  
  118.     }
  119. }
  120.  
  121. sub mkHeader
  122. {
  123.     my $self  = shift;
  124.     my $param = shift ;
  125.     
  126.     *$self->{ZipData}{StartOffset} = *$self->{ZipData}{Offset}->get32bit() ;
  127.  
  128.     my $filename = '';
  129.     $filename = $param->value('Name') || '';
  130.  
  131.     my $comment = '';
  132.     $comment = $param->value('Comment') || '';
  133.  
  134.     my $hdr = '';
  135.  
  136.     my $time = _unixToDosTime($param->value('Time'));
  137.  
  138.     my $extra = '';
  139.     my $ctlExtra = '';
  140.     my $empty = 0;
  141.     my $osCode = $param->value('OS_Code') ;
  142.     my $extFileAttr = 0 ;
  143.     
  144.     # This code assumes Unix.
  145.     $extFileAttr = 0666 << 16 
  146.         if $osCode == ZIP_OS_CODE_UNIX ;
  147.  
  148.     if (*$self->{ZipData}{Zip64}) {
  149.         $empty = 0xFFFF;
  150.  
  151.         my $x = '';
  152.         $x .= pack "V V", 0, 0 ; # uncompressedLength   
  153.         $x .= pack "V V", 0, 0 ; # compressedLength   
  154.         $x .= *$self->{ZipData}{Offset}->getPacked_V64() ; # offset to local hdr
  155.         #$x .= pack "V  ", 0    ; # disk no
  156.  
  157.         $x = IO::Compress::Zlib::Extra::mkSubField(ZIP_EXTRA_ID_ZIP64, $x);
  158.         $extra .= $x;
  159.         $ctlExtra .= $x;
  160.     }
  161.  
  162.     if (! $param->value('Minimal')) {
  163.         if (defined $param->value('exTime'))
  164.         {
  165.             $extra .= mkExtendedTime($param->value('MTime'), 
  166.                                     $param->value('ATime'), 
  167.                                     $param->value('CTime'));
  168.  
  169.             $ctlExtra .= mkExtendedTime($param->value('MTime'));
  170.         }
  171.  
  172.         if ( $param->value('UID') && $osCode == ZIP_OS_CODE_UNIX)
  173.         {
  174.             $extra    .= mkUnix2Extra( $param->value('UID'), $param->value('GID'));
  175.             $ctlExtra .= mkUnix2Extra();
  176.         }
  177.  
  178.         $extFileAttr = $param->value('ExtAttr') 
  179.             if defined $param->value('ExtAttr') ;
  180.  
  181.         $extra .= $param->value('ExtraFieldLocal') 
  182.             if defined $param->value('ExtraFieldLocal');
  183.  
  184.         $ctlExtra .= $param->value('ExtraFieldCentral') 
  185.             if defined $param->value('ExtraFieldCentral');
  186.     }
  187.  
  188.     my $gpFlag = 0 ;    
  189.     $gpFlag |= ZIP_GP_FLAG_STREAMING_MASK
  190.         if *$self->{ZipData}{Stream} ;
  191.  
  192.     my $method = *$self->{ZipData}{Method} ;
  193.  
  194.     my $version = $ZIP_CM_MIN_VERSIONS{$method};
  195.     $version = ZIP64_MIN_VERSION
  196.         if ZIP64_MIN_VERSION > $version && *$self->{ZipData}{Zip64};
  197.     my $madeBy = ($param->value('OS_Code') << 8) + $version;
  198.     my $extract = $version;
  199.  
  200.     *$self->{ZipData}{Version} = $version;
  201.     *$self->{ZipData}{MadeBy} = $madeBy;
  202.  
  203.     my $ifa = 0;
  204.     $ifa |= ZIP_IFA_TEXT_MASK
  205.         if $param->value('TextFlag');
  206.  
  207.     $hdr .= pack "V", ZIP_LOCAL_HDR_SIG ; # signature
  208.     $hdr .= pack 'v', $extract   ; # extract Version & OS
  209.     $hdr .= pack 'v', $gpFlag    ; # general purpose flag (set streaming mode)
  210.     $hdr .= pack 'v', $method    ; # compression method (deflate)
  211.     $hdr .= pack 'V', $time      ; # last mod date/time
  212.     $hdr .= pack 'V', 0          ; # crc32               - 0 when streaming
  213.     $hdr .= pack 'V', $empty     ; # compressed length   - 0 when streaming
  214.     $hdr .= pack 'V', $empty     ; # uncompressed length - 0 when streaming
  215.     $hdr .= pack 'v', length $filename ; # filename length
  216.     $hdr .= pack 'v', length $extra ; # extra length
  217.     
  218.     $hdr .= $filename ;
  219.     $hdr .= $extra ;
  220.  
  221.  
  222.     my $ctl = '';
  223.  
  224.     $ctl .= pack "V", ZIP_CENTRAL_HDR_SIG ; # signature
  225.     $ctl .= pack 'v', $madeBy    ; # version made by
  226.     $ctl .= pack 'v', $extract   ; # extract Version
  227.     $ctl .= pack 'v', $gpFlag    ; # general purpose flag (streaming mode)
  228.     $ctl .= pack 'v', $method    ; # compression method (deflate)
  229.     $ctl .= pack 'V', $time      ; # last mod date/time
  230.     $ctl .= pack 'V', 0          ; # crc32
  231.     $ctl .= pack 'V', $empty     ; # compressed length
  232.     $ctl .= pack 'V', $empty     ; # uncompressed length
  233.     $ctl .= pack 'v', length $filename ; # filename length
  234.     $ctl .= pack 'v', length $ctlExtra ; # extra length
  235.     $ctl .= pack 'v', length $comment ;  # file comment length
  236.     $ctl .= pack 'v', 0          ; # disk number start 
  237.     $ctl .= pack 'v', $ifa       ; # internal file attributes
  238.     $ctl .= pack 'V', $extFileAttr   ; # external file attributes
  239.     if (! *$self->{ZipData}{Zip64}) {
  240.         $ctl .= pack 'V', *$self->{ZipData}{Offset}->get32bit()  ; # offset to local header
  241.     }
  242.     else {
  243.         $ctl .= pack 'V', $empty ; # offset to local header
  244.     }
  245.     
  246.     $ctl .= $filename ;
  247.     *$self->{ZipData}{StartOffset64} = 4 + length $ctl;
  248.     $ctl .= $ctlExtra ;
  249.     $ctl .= $comment ;
  250.  
  251.     *$self->{ZipData}{Offset}->add(length $hdr) ;
  252.  
  253.     *$self->{ZipData}{CentralHeader} = $ctl;
  254.  
  255.     return $hdr;
  256. }
  257.  
  258. sub mkTrailer
  259. {
  260.     my $self = shift ;
  261.  
  262.     my $crc32 ;
  263.     if (*$self->{ZipData}{Method} == ZIP_CM_DEFLATE) {
  264.         $crc32 = pack "V", *$self->{Compress}->crc32();
  265.     }
  266.     else {
  267.         $crc32 = pack "V", *$self->{ZipData}{CRC32};
  268.     }
  269.  
  270.     my $ctl = *$self->{ZipData}{CentralHeader} ;
  271.  
  272.     my $sizes ;
  273.     if (! *$self->{ZipData}{Zip64}) {
  274.         $sizes .= *$self->{CompSize}->getPacked_V32() ;   # Compressed size
  275.         $sizes .= *$self->{UnCompSize}->getPacked_V32() ; # Uncompressed size
  276.     }
  277.     else {
  278.         $sizes .= *$self->{CompSize}->getPacked_V64() ;   # Compressed size
  279.         $sizes .= *$self->{UnCompSize}->getPacked_V64() ; # Uncompressed size
  280.     }
  281.  
  282.     my $data = $crc32 . $sizes ;
  283.  
  284.  
  285.     my $hdr = '';
  286.  
  287.     if (*$self->{ZipData}{Stream}) {
  288.         $hdr  = pack "V", ZIP_DATA_HDR_SIG ;                       # signature
  289.         $hdr .= $data ;
  290.     }
  291.     else {
  292.         $self->writeAt(*$self->{ZipData}{StartOffset} + 14, $data)
  293.             or return undef;
  294.     }
  295.  
  296.     if (! *$self->{ZipData}{Zip64})
  297.       { substr($ctl, 16, length $data) = $data }
  298.     else {
  299.         substr($ctl, 16, length $crc32) = $crc32 ;
  300.         my $s  = *$self->{UnCompSize}->getPacked_V64() ; # Uncompressed size
  301.            $s .= *$self->{CompSize}->getPacked_V64() ;   # Compressed size
  302.         substr($ctl, *$self->{ZipData}{StartOffset64}, length $s) = $s ;
  303.     }
  304.  
  305.     *$self->{ZipData}{Offset}->add(length($hdr));
  306.     *$self->{ZipData}{Offset}->add( *$self->{CompSize} );
  307.     push @{ *$self->{ZipData}{CentralDir} }, $ctl ;
  308.  
  309.     return $hdr;
  310. }
  311.  
  312. sub mkFinalTrailer
  313. {
  314.     my $self = shift ;
  315.  
  316.     my $comment = '';
  317.     $comment = *$self->{ZipData}{ZipComment} ;
  318.  
  319.     my $cd_offset = *$self->{ZipData}{Offset}->get32bit() ; # offset to start central dir
  320.  
  321.     my $entries = @{ *$self->{ZipData}{CentralDir} };
  322.     my $cd = join '', @{ *$self->{ZipData}{CentralDir} };
  323.     my $cd_len = length $cd ;
  324.  
  325.     my $z64e = '';
  326.  
  327.     if ( *$self->{ZipData}{Zip64} ) {
  328.  
  329.         my $v  = *$self->{ZipData}{Version} ;
  330.         my $mb = *$self->{ZipData}{MadeBy} ;
  331.         $z64e .= pack 'v', $v             ; # Version made by
  332.         $z64e .= pack 'v', $mb            ; # Version to extract
  333.         $z64e .= pack 'V', 0              ; # number of disk
  334.         $z64e .= pack 'V', 0              ; # number of disk with central dir
  335.         $z64e .= U64::pack_V64 $entries   ; # entries in central dir on this disk
  336.         $z64e .= U64::pack_V64 $entries   ; # entries in central dir
  337.         $z64e .= U64::pack_V64 $cd_len    ; # size of central dir
  338.         $z64e .= *$self->{ZipData}{Offset}->getPacked_V64() ; # offset to start central dir
  339.  
  340.         $z64e  = pack("V", ZIP64_END_CENTRAL_REC_HDR_SIG) # signature
  341.               .  U64::pack_V64(length $z64e)
  342.               .  $z64e ;
  343.  
  344.         *$self->{ZipData}{Offset}->add(length $cd) ; 
  345.  
  346.         $z64e .= pack "V", ZIP64_END_CENTRAL_LOC_HDR_SIG; # signature
  347.         $z64e .= pack 'V', 0              ; # number of disk with central dir
  348.         $z64e .= *$self->{ZipData}{Offset}->getPacked_V64() ; # offset to end zip64 central dir
  349.         $z64e .= pack 'V', 1              ; # Total number of disks 
  350.  
  351.         # TODO - fix these when info-zip 3 is fixed.
  352.         #$cd_len = 
  353.         #$cd_offset = 
  354.         $entries = 0xFFFF ;
  355.     }
  356.  
  357.     my $ecd = '';
  358.     $ecd .= pack "V", ZIP_END_CENTRAL_HDR_SIG ; # signature
  359.     $ecd .= pack 'v', 0          ; # number of disk
  360.     $ecd .= pack 'v', 0          ; # number of disk with central dir
  361.     $ecd .= pack 'v', $entries   ; # entries in central dir on this disk
  362.     $ecd .= pack 'v', $entries   ; # entries in central dir
  363.     $ecd .= pack 'V', $cd_len    ; # size of central dir
  364.     $ecd .= pack 'V', $cd_offset ; # offset to start central dir
  365.     $ecd .= pack 'v', length $comment ; # zipfile comment length
  366.     $ecd .= $comment;
  367.  
  368.     return $cd . $z64e . $ecd ;
  369. }
  370.  
  371. sub ckParams
  372. {
  373.     my $self = shift ;
  374.     my $got = shift;
  375.     
  376.     $got->value('CRC32' => 1);
  377.  
  378.     if (! $got->parsed('Time') ) {
  379.         # Modification time defaults to now.
  380.         $got->value('Time' => time) ;
  381.     }
  382.  
  383.     if (! $got->parsed('exTime') ) {
  384.         my $timeRef = $got->value('exTime');
  385.         if ( defined $timeRef) {
  386.             return $self->saveErrorString(undef, "exTime not a 3-element array ref")   
  387.                 if ref $timeRef ne 'ARRAY' || @$timeRef != 3;
  388.         }
  389.  
  390.         $got->value("MTime", $timeRef->[1]);
  391.         $got->value("ATime", $timeRef->[0]);
  392.         $got->value("CTime", $timeRef->[2]);
  393.     }
  394.     
  395.     # Unix2 Extended Attribute
  396.     if (! $got->parsed('exUnix2') ) {
  397.         my $timeRef = $got->value('exUnix2');
  398.         if ( defined $timeRef) {
  399.             return $self->saveErrorString(undef, "exUnix2 not a 2-element array ref")   
  400.                 if ref $timeRef ne 'ARRAY' || @$timeRef != 2;
  401.         }
  402.  
  403.         $got->value("UID", $timeRef->[0]);
  404.         $got->value("GID", $timeRef->[1]);
  405.     }
  406.  
  407.     *$self->{ZipData}{Zip64} = $got->value('Zip64');
  408.     *$self->{ZipData}{Stream} = $got->value('Stream');
  409.  
  410.     return $self->saveErrorString(undef, "Zip64 only supported if Stream enabled")   
  411.         if  *$self->{ZipData}{Zip64} && ! *$self->{ZipData}{Stream} ;
  412.  
  413.     my $method = $got->value('Method');
  414.     return $self->saveErrorString(undef, "Unknown Method '$method'")   
  415.         if ! defined $ZIP_CM_MIN_VERSIONS{$method};
  416.  
  417.     return $self->saveErrorString(undef, "Bzip2 not available")
  418.         if $method == ZIP_CM_BZIP2 and 
  419.            ! defined $IO::Compress::Adapter::Bzip2::VERSION;
  420.  
  421.     *$self->{ZipData}{Method} = $method;
  422.  
  423.     *$self->{ZipData}{ZipComment} = $got->value('ZipComment') ;
  424.  
  425.     for my $name (qw( ExtraFieldLocal ExtraFieldCentral ))
  426.     {
  427.         my $data = $got->value($name) ;
  428.         if (defined $data) {
  429.             my $bad = IO::Compress::Zlib::Extra::parseExtraField($data, 1, 0) ;
  430.             return $self->saveErrorString(undef, "Error with $name Parameter: $bad")
  431.                 if $bad ;
  432.  
  433.             $got->value($name, $data) ;
  434.         }
  435.     }
  436.  
  437.     return undef
  438.         if defined $IO::Compress::Bzip2::VERSION
  439.             and ! IO::Compress::Bzip2::ckParams($self, $got);
  440.  
  441.     return 1 ;
  442. }
  443.  
  444. #sub newHeader
  445. #{
  446. #    my $self = shift ;
  447. #
  448. #    return $self->mkHeader(*$self->{Got});
  449. #}
  450.  
  451. sub getExtraParams
  452. {
  453.     my $self = shift ;
  454.  
  455.     use IO::Compress::Base::Common  2.015 qw(:Parse);
  456.     use Compress::Raw::Zlib  2.015 qw(Z_DEFLATED Z_DEFAULT_COMPRESSION Z_DEFAULT_STRATEGY);
  457.  
  458.     my @Bzip2 = ();
  459.     
  460.     @Bzip2 = IO::Compress::Bzip2::getExtraParams($self)
  461.         if defined $IO::Compress::Bzip2::VERSION;
  462.     
  463.     return (
  464.             # zlib behaviour
  465.             $self->getZlibParams(),
  466.  
  467.             'Stream'    => [1, 1, Parse_boolean,   1],
  468.            #'Store'     => [0, 1, Parse_boolean,   0],
  469.             'Method'    => [0, 1, Parse_unsigned,  ZIP_CM_DEFLATE],
  470.             
  471. #            # Zip header fields
  472.             'Minimal'   => [0, 1, Parse_boolean,   0],
  473.             'Zip64'     => [0, 1, Parse_boolean,   0],
  474.             'Comment'   => [0, 1, Parse_any,       ''],
  475.             'ZipComment'=> [0, 1, Parse_any,       ''],
  476.             'Name'      => [0, 1, Parse_any,       ''],
  477.             'Time'      => [0, 1, Parse_any,       undef],
  478.             'exTime'    => [0, 1, Parse_any,       undef],
  479.             'exUnix2'   => [0, 1, Parse_any,       undef], 
  480.             'ExtAttr'   => [0, 1, Parse_any,       0],
  481.             'OS_Code'   => [0, 1, Parse_unsigned,  $Compress::Raw::Zlib::gzip_os_code],
  482.             
  483.            'TextFlag'  => [0, 1, Parse_boolean,   0],
  484.            'ExtraFieldLocal'  => [0, 1, Parse_any,    undef],
  485.            'ExtraFieldCentral'=> [0, 1, Parse_any,    undef],
  486.  
  487.             @Bzip2,
  488.         );
  489. }
  490.  
  491. sub getInverseClass
  492. {
  493.     return ('IO::Uncompress::Unzip',
  494.                 \$IO::Uncompress::Unzip::UnzipError);
  495. }
  496.  
  497. sub getFileInfo
  498. {
  499.     my $self = shift ;
  500.     my $params = shift;
  501.     my $filename = shift ;
  502.  
  503.     my ($mode, $uid, $gid, $atime, $mtime, $ctime) 
  504.                 = (stat($filename))[2, 4,5, 8,9,10] ;
  505.  
  506.     $params->value('Name' => $filename)
  507.         if ! $params->parsed('Name') ;
  508.  
  509.     $params->value('Time' => $mtime) 
  510.         if ! $params->parsed('Time') ;
  511.     
  512.     if ( ! $params->parsed('exTime'))
  513.     {
  514.         $params->value('MTime' => $mtime) ;
  515.         $params->value('ATime' => $atime) ;
  516.         $params->value('CTime' => undef) ; # No Creation time
  517.     }
  518.  
  519.     # NOTE - Unix specific code alert
  520.     $params->value('ExtAttr' => $mode << 16) 
  521.         if ! $params->parsed('ExtAttr');
  522.  
  523.     $params->value('UID' => $uid) ;
  524.     $params->value('GID' => $gid) ;
  525.     
  526. }
  527.  
  528. sub mkExtendedTime
  529. {
  530.     # order expected is m, a, c
  531.  
  532.     my $times = '';
  533.     my $bit = 1 ;
  534.     my $flags = 0;
  535.  
  536.     for my $time (@_)
  537.     {
  538.         if (defined $time)
  539.         {
  540.             $flags |= $bit;
  541.             $times .= pack("V", $time);
  542.         }
  543.  
  544.         $bit <<= 1 ;
  545.     }
  546.  
  547.     return IO::Compress::Zlib::Extra::mkSubField(ZIP_EXTRA_ID_EXT_TIMESTAMP,
  548.                                                  pack("C", $flags) .  $times);
  549. }
  550.  
  551. sub mkUnix2Extra
  552. {
  553.     my $ids = '';
  554.     for my $id (@_)
  555.     {
  556.         $ids .= pack("v", $id);
  557.     }
  558.  
  559.     return IO::Compress::Zlib::Extra::mkSubField(ZIP_EXTRA_ID_INFO_ZIP_UNIX2, 
  560.                                                  $ids);
  561. }
  562.  
  563.  
  564. # from Archive::Zip
  565. sub _unixToDosTime    # Archive::Zip::Member
  566. {
  567.     my $time_t = shift;
  568.     # TODO - add something to cope with unix time < 1980 
  569.     my ( $sec, $min, $hour, $mday, $mon, $year ) = localtime($time_t);
  570.     my $dt = 0;
  571.     $dt += ( $sec >> 1 );
  572.     $dt += ( $min << 5 );
  573.     $dt += ( $hour << 11 );
  574.     $dt += ( $mday << 16 );
  575.     $dt += ( ( $mon + 1 ) << 21 );
  576.     $dt += ( ( $year - 80 ) << 25 );
  577.     return $dt;
  578. }
  579.  
  580. 1;
  581.  
  582. __END__
  583.  
  584. =head1 NAME
  585.  
  586. IO::Compress::Zip - Write zip files/buffers
  587.  
  588.  
  589.  
  590. =head1 SYNOPSIS
  591.  
  592.     use IO::Compress::Zip qw(zip $ZipError) ;
  593.  
  594.     my $status = zip $input => $output [,OPTS] 
  595.         or die "zip failed: $ZipError\n";
  596.  
  597.     my $z = new IO::Compress::Zip $output [,OPTS]
  598.         or die "zip failed: $ZipError\n";
  599.  
  600.     $z->print($string);
  601.     $z->printf($format, $string);
  602.     $z->write($string);
  603.     $z->syswrite($string [, $length, $offset]);
  604.     $z->flush();
  605.     $z->tell();
  606.     $z->eof();
  607.     $z->seek($position, $whence);
  608.     $z->binmode();
  609.     $z->fileno();
  610.     $z->opened();
  611.     $z->autoflush();
  612.     $z->input_line_number();
  613.     $z->newStream( [OPTS] );
  614.     
  615.     $z->deflateParams();
  616.     
  617.     $z->close() ;
  618.  
  619.     $ZipError ;
  620.  
  621.     # IO::File mode
  622.  
  623.     print $z $string;
  624.     printf $z $format, $string;
  625.     tell $z
  626.     eof $z
  627.     seek $z, $position, $whence
  628.     binmode $z
  629.     fileno $z
  630.     close $z ;
  631.     
  632.  
  633. =head1 DESCRIPTION
  634.  
  635. This module provides a Perl interface that allows writing zip 
  636. compressed data to files or buffer.
  637.  
  638. The primary purpose of this module is to provide streaming write access to
  639. zip files and buffers. It is not a general-purpose file archiver. If that
  640. is what you want, check out C<Archive::Zip>.
  641.  
  642. At present three compression methods are supported by IO::Compress::Zip,
  643. namely Store (no compression at all), Deflate and Bzip2.
  644.  
  645. Note that to create Bzip2 content, the module C<IO::Compress::Bzip2> must
  646. be installed.
  647.  
  648. For reading zip files/buffers, see the companion module 
  649. L<IO::Uncompress::Unzip|IO::Uncompress::Unzip>.
  650.  
  651. =head1 Functional Interface
  652.  
  653. A top-level function, C<zip>, is provided to carry out
  654. "one-shot" compression between buffers and/or files. For finer
  655. control over the compression process, see the L</"OO Interface">
  656. section.
  657.  
  658.     use IO::Compress::Zip qw(zip $ZipError) ;
  659.  
  660.     zip $input => $output [,OPTS] 
  661.         or die "zip failed: $ZipError\n";
  662.  
  663. The functional interface needs Perl5.005 or better.
  664.  
  665. =head2 zip $input => $output [, OPTS]
  666.  
  667. C<zip> expects at least two parameters, C<$input> and C<$output>.
  668.  
  669. =head3 The C<$input> parameter
  670.  
  671. The parameter, C<$input>, is used to define the source of
  672. the uncompressed data. 
  673.  
  674. It can take one of the following forms:
  675.  
  676. =over 5
  677.  
  678. =item A filename
  679.  
  680. If the C<$input> parameter is a simple scalar, it is assumed to be a
  681. filename. This file will be opened for reading and the input data
  682. will be read from it.
  683.  
  684. =item A filehandle
  685.  
  686. If the C<$input> parameter is a filehandle, the input data will be
  687. read from it.
  688. The string '-' can be used as an alias for standard input.
  689.  
  690. =item A scalar reference 
  691.  
  692. If C<$input> is a scalar reference, the input data will be read
  693. from C<$$input>.
  694.  
  695. =item An array reference 
  696.  
  697. If C<$input> is an array reference, each element in the array must be a
  698. filename.
  699.  
  700. The input data will be read from each file in turn. 
  701.  
  702. The complete array will be walked to ensure that it only
  703. contains valid filenames before any data is compressed.
  704.  
  705. =item An Input FileGlob string
  706.  
  707. If C<$input> is a string that is delimited by the characters "<" and ">"
  708. C<zip> will assume that it is an I<input fileglob string>. The
  709. input is the list of files that match the fileglob.
  710.  
  711. If the fileglob does not match any files ...
  712.  
  713. See L<File::GlobMapper|File::GlobMapper> for more details.
  714.  
  715. =back
  716.  
  717. If the C<$input> parameter is any other type, C<undef> will be returned.
  718.  
  719. In addition, if C<$input> is a simple filename, the default values for
  720. the C<Name>, C<Time>, C<ExtAttr> and C<exTime> options will be sourced from that file.
  721.  
  722. If you do not want to use these defaults they can be overridden by
  723. explicitly setting the C<Name>, C<Time>, C<ExtAttr> and C<exTime> options or by setting the
  724. C<Minimal> parameter.
  725.  
  726. =head3 The C<$output> parameter
  727.  
  728. The parameter C<$output> is used to control the destination of the
  729. compressed data. This parameter can take one of these forms.
  730.  
  731. =over 5
  732.  
  733. =item A filename
  734.  
  735. If the C<$output> parameter is a simple scalar, it is assumed to be a
  736. filename.  This file will be opened for writing and the compressed
  737. data will be written to it.
  738.  
  739. =item A filehandle
  740.  
  741. If the C<$output> parameter is a filehandle, the compressed data
  742. will be written to it.
  743. The string '-' can be used as an alias for standard output.
  744.  
  745. =item A scalar reference 
  746.  
  747. If C<$output> is a scalar reference, the compressed data will be
  748. stored in C<$$output>.
  749.  
  750. =item An Array Reference
  751.  
  752. If C<$output> is an array reference, the compressed data will be
  753. pushed onto the array.
  754.  
  755. =item An Output FileGlob
  756.  
  757. If C<$output> is a string that is delimited by the characters "<" and ">"
  758. C<zip> will assume that it is an I<output fileglob string>. The
  759. output is the list of files that match the fileglob.
  760.  
  761. When C<$output> is an fileglob string, C<$input> must also be a fileglob
  762. string. Anything else is an error.
  763.  
  764. =back
  765.  
  766. If the C<$output> parameter is any other type, C<undef> will be returned.
  767.  
  768. =head2 Notes
  769.  
  770. When C<$input> maps to multiple files/buffers and C<$output> is a single
  771. file/buffer the input files/buffers will each be stored
  772. in C<$output> as a distinct entry.
  773.  
  774. =head2 Optional Parameters
  775.  
  776. Unless specified below, the optional parameters for C<zip>,
  777. C<OPTS>, are the same as those used with the OO interface defined in the
  778. L</"Constructor Options"> section below.
  779.  
  780. =over 5
  781.  
  782. =item C<< AutoClose => 0|1 >>
  783.  
  784. This option applies to any input or output data streams to 
  785. C<zip> that are filehandles.
  786.  
  787. If C<AutoClose> is specified, and the value is true, it will result in all
  788. input and/or output filehandles being closed once C<zip> has
  789. completed.
  790.  
  791. This parameter defaults to 0.
  792.  
  793. =item C<< BinModeIn => 0|1 >>
  794.  
  795. When reading from a file or filehandle, set C<binmode> before reading.
  796.  
  797. Defaults to 0.
  798.  
  799. =item C<< Append => 0|1 >>
  800.  
  801. TODO
  802.  
  803. =back
  804.  
  805. =head2 Examples
  806.  
  807. To read the contents of the file C<file1.txt> and write the compressed
  808. data to the file C<file1.txt.zip>.
  809.  
  810.     use strict ;
  811.     use warnings ;
  812.     use IO::Compress::Zip qw(zip $ZipError) ;
  813.  
  814.     my $input = "file1.txt";
  815.     zip $input => "$input.zip"
  816.         or die "zip failed: $ZipError\n";
  817.  
  818. To read from an existing Perl filehandle, C<$input>, and write the
  819. compressed data to a buffer, C<$buffer>.
  820.  
  821.     use strict ;
  822.     use warnings ;
  823.     use IO::Compress::Zip qw(zip $ZipError) ;
  824.     use IO::File ;
  825.  
  826.     my $input = new IO::File "<file1.txt"
  827.         or die "Cannot open 'file1.txt': $!\n" ;
  828.     my $buffer ;
  829.     zip $input => \$buffer 
  830.         or die "zip failed: $ZipError\n";
  831.  
  832. To compress all files in the directory "/my/home" that match "*.txt"
  833. and store the compressed data in the same directory
  834.  
  835.     use strict ;
  836.     use warnings ;
  837.     use IO::Compress::Zip qw(zip $ZipError) ;
  838.  
  839.     zip '</my/home/*.txt>' => '<*.zip>'
  840.         or die "zip failed: $ZipError\n";
  841.  
  842. and if you want to compress each file one at a time, this will do the trick
  843.  
  844.     use strict ;
  845.     use warnings ;
  846.     use IO::Compress::Zip qw(zip $ZipError) ;
  847.  
  848.     for my $input ( glob "/my/home/*.txt" )
  849.     {
  850.         my $output = "$input.zip" ;
  851.         zip $input => $output 
  852.             or die "Error compressing '$input': $ZipError\n";
  853.     }
  854.  
  855. =head1 OO Interface
  856.  
  857. =head2 Constructor
  858.  
  859. The format of the constructor for C<IO::Compress::Zip> is shown below
  860.  
  861.     my $z = new IO::Compress::Zip $output [,OPTS]
  862.         or die "IO::Compress::Zip failed: $ZipError\n";
  863.  
  864. It returns an C<IO::Compress::Zip> object on success and undef on failure. 
  865. The variable C<$ZipError> will contain an error message on failure.
  866.  
  867. If you are running Perl 5.005 or better the object, C<$z>, returned from 
  868. IO::Compress::Zip can be used exactly like an L<IO::File|IO::File> filehandle. 
  869. This means that all normal output file operations can be carried out 
  870. with C<$z>. 
  871. For example, to write to a compressed file/buffer you can use either of 
  872. these forms
  873.  
  874.     $z->print("hello world\n");
  875.     print $z "hello world\n";
  876.  
  877. The mandatory parameter C<$output> is used to control the destination
  878. of the compressed data. This parameter can take one of these forms.
  879.  
  880. =over 5
  881.  
  882. =item A filename
  883.  
  884. If the C<$output> parameter is a simple scalar, it is assumed to be a
  885. filename. This file will be opened for writing and the compressed data
  886. will be written to it.
  887.  
  888. =item A filehandle
  889.  
  890. If the C<$output> parameter is a filehandle, the compressed data will be
  891. written to it.
  892. The string '-' can be used as an alias for standard output.
  893.  
  894. =item A scalar reference 
  895.  
  896. If C<$output> is a scalar reference, the compressed data will be stored
  897. in C<$$output>.
  898.  
  899. =back
  900.  
  901. If the C<$output> parameter is any other type, C<IO::Compress::Zip>::new will
  902. return undef.
  903.  
  904. =head2 Constructor Options
  905.  
  906. C<OPTS> is any combination of the following options:
  907.  
  908. =over 5
  909.  
  910. =item C<< AutoClose => 0|1 >>
  911.  
  912. This option is only valid when the C<$output> parameter is a filehandle. If
  913. specified, and the value is true, it will result in the C<$output> being
  914. closed once either the C<close> method is called or the C<IO::Compress::Zip>
  915. object is destroyed.
  916.  
  917. This parameter defaults to 0.
  918.  
  919. =item C<< Append => 0|1 >>
  920.  
  921. Opens C<$output> in append mode. 
  922.  
  923. The behaviour of this option is dependent on the type of C<$output>.
  924.  
  925. =over 5
  926.  
  927. =item * A Buffer
  928.  
  929. If C<$output> is a buffer and C<Append> is enabled, all compressed data
  930. will be append to the end if C<$output>. Otherwise C<$output> will be
  931. cleared before any data is written to it.
  932.  
  933. =item * A Filename
  934.  
  935. If C<$output> is a filename and C<Append> is enabled, the file will be
  936. opened in append mode. Otherwise the contents of the file, if any, will be
  937. truncated before any compressed data is written to it.
  938.  
  939. =item * A Filehandle
  940.  
  941. If C<$output> is a filehandle, the file pointer will be positioned to the
  942. end of the file via a call to C<seek> before any compressed data is written
  943. to it.  Otherwise the file pointer will not be moved.
  944.  
  945. =back
  946.  
  947. This parameter defaults to 0.
  948.  
  949. =item C<< Name => $string >>
  950.  
  951. Stores the contents of C<$string> in the zip filename header field. If
  952. C<Name> is not specified, no zip filename field will be created.
  953.  
  954. =item C<< Time => $number >>
  955.  
  956. Sets the last modified time field in the zip header to $number.
  957.  
  958. This field defaults to the time the C<IO::Compress::Zip> object was created
  959. if this option is not specified.
  960.  
  961. =item C<< ExtAttr => $attr >>
  962.  
  963. This option controls the "external file attributes" field in the central
  964. header of the zip file. This is a 4 byte field.
  965.  
  966. If you are running a Unix derivative this value defaults to 
  967.  
  968.     0666 << 16
  969.  
  970. This should allow read/write access to any files that are extracted from
  971. the zip file/buffer.
  972.  
  973. For all other systems it defaults to 0.
  974.  
  975. =item C<< exTime => [$atime, $mtime, $ctime] >>
  976.  
  977. This option expects an array reference with exactly three elements:
  978. C<$atime>, C<mtime> and C<$ctime>. These correspond to the last access
  979. time, last modification time and creation time respectively.
  980.  
  981. It uses these values to set the extended timestamp field (ID is "UT") in
  982. the local zip header using the three values, $atime, $mtime, $ctime. In
  983. addition it sets the extended timestamp field in the central zip header
  984. using C<$mtime>.
  985.  
  986. If any of the three values is C<undef> that time value will not be used.
  987. So, for example, to set only the C<$mtime> you would use this
  988.  
  989.     exTime => [undef, $mtime, undef]
  990.  
  991. If the C<Minimal> option is set to true, this option will be ignored.
  992.  
  993. By default no extended time field is created.
  994.  
  995. =item C<< exUnix2 => [$uid, $gid] >>
  996.  
  997. This option expects an array reference with exactly two elements: C<$uid>
  998. and C<$gid>. These values correspond to the numeric user ID and group ID
  999. of the owner of the files respectively.
  1000.  
  1001. When the C<exUnix2> option is present it will trigger the creation of a
  1002. Unix2 extra field (ID is "Ux") in the local zip. This will be populated
  1003. with C<$uid> and C<$gid>. In addition an empty Unix2 extra field will also
  1004. be created in the central zip header
  1005.  
  1006. If the C<Minimal> option is set to true, this option will be ignored.
  1007.  
  1008. By default no Unix2 extra field is created.
  1009.  
  1010. =item C<< Comment => $comment >>
  1011.  
  1012. Stores the contents of C<$comment> in the Central File Header of
  1013. the zip file.
  1014.  
  1015. By default, no comment field is written to the zip file.
  1016.  
  1017. =item C<< ZipComment => $comment >>
  1018.  
  1019. Stores the contents of C<$comment> in the End of Central Directory record
  1020. of the zip file.
  1021.  
  1022. By default, no comment field is written to the zip file.
  1023.  
  1024. =item C<< Method => $method >>
  1025.  
  1026. Controls which compression method is used. At present three compression
  1027. methods are supported, namely Store (no compression at all), Deflate and
  1028. Bzip2.
  1029.  
  1030. The symbols, ZIP_CM_STORE, ZIP_CM_DEFLATE and ZIP_CM_BZIP2 are used to
  1031. select the compression method.
  1032.  
  1033. These constants are not imported by C<IO::Compress::Zip> by default.
  1034.  
  1035.     use IO::Compress::Zip qw(:zip_method);
  1036.     use IO::Compress::Zip qw(:constants);
  1037.     use IO::Compress::Zip qw(:all);
  1038.  
  1039. Note that to create Bzip2 content, the module C<IO::Compress::Bzip2> must
  1040. be installed. A fatal error will be thrown if you attempt to create Bzip2
  1041. content when C<IO::Compress::Bzip2> is not available.
  1042.  
  1043. The default method is ZIP_CM_DEFLATE.
  1044.  
  1045. =item C<< Stream => 0|1 >>
  1046.  
  1047. This option controls whether the zip file/buffer output is created in
  1048. streaming mode.
  1049.  
  1050. Note that when outputting to a file with streaming mode disabled (C<Stream>
  1051. is 0), the output file must be seekable.
  1052.  
  1053. The default is 1.
  1054.  
  1055. =item C<< Zip64 => 0|1 >>
  1056.  
  1057. Create a Zip64 zip file/buffer. This option should only be used if you want
  1058. to store files larger than 4 Gig.
  1059.  
  1060. If you intend to manipulate the Zip64 zip files created with this module
  1061. using an external zip/unzip make sure that it supports streaming Zip64.  
  1062.  
  1063. In particular, if you are using Info-Zip you need to have zip version 3.x
  1064. or better to update a Zip64 archive and unzip version 6.x to read a zip64
  1065. archive. At the time of writing both are beta status.
  1066.  
  1067. When the C<Zip64> option is enabled, the C<Stream> option I<must> be
  1068. enabled as well.
  1069.  
  1070. The default is 0.
  1071.  
  1072. =item C<< TextFlag => 0|1 >>
  1073.  
  1074. This parameter controls the setting of a bit in the zip central header. It
  1075. is used to signal that the data stored in the zip file/buffer is probably
  1076. text.
  1077.  
  1078. The default is 0. 
  1079.  
  1080. =item C<< ExtraFieldLocal => $data >>
  1081. =item C<< ExtraFieldCentral => $data >>
  1082.  
  1083. The C<ExtraFieldLocal> option is used to store additional metadata in the
  1084. local header for the zip file/buffer. The C<ExtraFieldCentral> does the
  1085. same for the matching central header.
  1086.  
  1087. An extra field consists of zero or more subfields. Each subfield consists
  1088. of a two byte header followed by the subfield data.
  1089.  
  1090. The list of subfields can be supplied in any of the following formats
  1091.  
  1092.     ExtraFieldLocal => [$id1, $data1,
  1093.                         $id2, $data2,
  1094.                          ...
  1095.                        ]
  1096.  
  1097.     ExtraFieldLocal => [ [$id1 => $data1],
  1098.                          [$id2 => $data2],
  1099.                          ...
  1100.                        ]
  1101.  
  1102.     ExtraFieldLocal => { $id1 => $data1,
  1103.                          $id2 => $data2,
  1104.                          ...
  1105.                        }
  1106.  
  1107. Where C<$id1>, C<$id2> are two byte subfield ID's. 
  1108.  
  1109. If you use the hash syntax, you have no control over the order in which
  1110. the ExtraSubFields are stored, plus you cannot have SubFields with
  1111. duplicate ID.
  1112.  
  1113. Alternatively the list of subfields can by supplied as a scalar, thus
  1114.  
  1115.     ExtraField => $rawdata
  1116.  
  1117. The Extended Time field (ID "UT"), set using the C<exTime> option, and the
  1118. Unix2 extra field (ID "Ux), set using the C<exUnix2> option, are examples
  1119. of extra fields.
  1120.  
  1121. If the C<Minimal> option is set to true, this option will be ignored.
  1122.  
  1123. The maximum size of an extra field 65535 bytes.
  1124.  
  1125. =item C<< Minimal => 1|0 >>
  1126.  
  1127. If specified, this option will disable the creation of all extra fields
  1128. in the zip local and central headers. So the C<exTime>, C<exUnix2>,
  1129. C<ExtraFieldLocal> and C<ExtraFieldCentral> options will be ignored.
  1130.  
  1131. This parameter defaults to 0.
  1132.  
  1133. =item C<< BlockSize100K => number >>
  1134.  
  1135. Specify the number of 100K blocks bzip2 uses during compression. 
  1136.  
  1137. Valid values are from 1 to 9, where 9 is best compression.
  1138.  
  1139. This option is only valid if the C<Method> is ZIP_CM_BZIP2. It is ignored
  1140. otherwise.
  1141.  
  1142. The default is 1.
  1143.  
  1144. =item C<< WorkFactor => number >>
  1145.  
  1146. Specifies how much effort bzip2 should take before resorting to a slower
  1147. fallback compression algorithm.
  1148.  
  1149. Valid values range from 0 to 250, where 0 means use the default value 30.
  1150.  
  1151. This option is only valid if the C<Method> is ZIP_CM_BZIP2. It is ignored
  1152. otherwise.
  1153.  
  1154. The default is 0.
  1155.  
  1156. =item -Level 
  1157.  
  1158. Defines the compression level used by zlib. The value should either be
  1159. a number between 0 and 9 (0 means no compression and 9 is maximum
  1160. compression), or one of the symbolic constants defined below.
  1161.  
  1162.    Z_NO_COMPRESSION
  1163.    Z_BEST_SPEED
  1164.    Z_BEST_COMPRESSION
  1165.    Z_DEFAULT_COMPRESSION
  1166.  
  1167. The default is Z_DEFAULT_COMPRESSION.
  1168.  
  1169. Note, these constants are not imported by C<IO::Compress::Zip> by default.
  1170.  
  1171.     use IO::Compress::Zip qw(:strategy);
  1172.     use IO::Compress::Zip qw(:constants);
  1173.     use IO::Compress::Zip qw(:all);
  1174.  
  1175. =item -Strategy 
  1176.  
  1177. Defines the strategy used to tune the compression. Use one of the symbolic
  1178. constants defined below.
  1179.  
  1180.    Z_FILTERED
  1181.    Z_HUFFMAN_ONLY
  1182.    Z_RLE
  1183.    Z_FIXED
  1184.    Z_DEFAULT_STRATEGY
  1185.  
  1186. The default is Z_DEFAULT_STRATEGY.
  1187.  
  1188. =item C<< Strict => 0|1 >>
  1189.  
  1190. This is a placeholder option.
  1191.  
  1192. =back
  1193.  
  1194. =head2 Examples
  1195.  
  1196. TODO
  1197.  
  1198. =head1 Methods 
  1199.  
  1200. =head2 print
  1201.  
  1202. Usage is
  1203.  
  1204.     $z->print($data)
  1205.     print $z $data
  1206.  
  1207. Compresses and outputs the contents of the C<$data> parameter. This
  1208. has the same behaviour as the C<print> built-in.
  1209.  
  1210. Returns true if successful.
  1211.  
  1212. =head2 printf
  1213.  
  1214. Usage is
  1215.  
  1216.     $z->printf($format, $data)
  1217.     printf $z $format, $data
  1218.  
  1219. Compresses and outputs the contents of the C<$data> parameter.
  1220.  
  1221. Returns true if successful.
  1222.  
  1223. =head2 syswrite
  1224.  
  1225. Usage is
  1226.  
  1227.     $z->syswrite $data
  1228.     $z->syswrite $data, $length
  1229.     $z->syswrite $data, $length, $offset
  1230.  
  1231. Compresses and outputs the contents of the C<$data> parameter.
  1232.  
  1233. Returns the number of uncompressed bytes written, or C<undef> if
  1234. unsuccessful.
  1235.  
  1236. =head2 write
  1237.  
  1238. Usage is
  1239.  
  1240.     $z->write $data
  1241.     $z->write $data, $length
  1242.     $z->write $data, $length, $offset
  1243.  
  1244. Compresses and outputs the contents of the C<$data> parameter.
  1245.  
  1246. Returns the number of uncompressed bytes written, or C<undef> if
  1247. unsuccessful.
  1248.  
  1249. =head2 flush
  1250.  
  1251. Usage is
  1252.  
  1253.     $z->flush;
  1254.     $z->flush($flush_type);
  1255.  
  1256. Flushes any pending compressed data to the output file/buffer.
  1257.  
  1258. This method takes an optional parameter, C<$flush_type>, that controls
  1259. how the flushing will be carried out. By default the C<$flush_type>
  1260. used is C<Z_FINISH>. Other valid values for C<$flush_type> are
  1261. C<Z_NO_FLUSH>, C<Z_SYNC_FLUSH>, C<Z_FULL_FLUSH> and C<Z_BLOCK>. It is
  1262. strongly recommended that you only set the C<flush_type> parameter if
  1263. you fully understand the implications of what it does - overuse of C<flush>
  1264. can seriously degrade the level of compression achieved. See the C<zlib>
  1265. documentation for details.
  1266.  
  1267. Returns true on success.
  1268.  
  1269. =head2 tell
  1270.  
  1271. Usage is
  1272.  
  1273.     $z->tell()
  1274.     tell $z
  1275.  
  1276. Returns the uncompressed file offset.
  1277.  
  1278. =head2 eof
  1279.  
  1280. Usage is
  1281.  
  1282.     $z->eof();
  1283.     eof($z);
  1284.  
  1285. Returns true if the C<close> method has been called.
  1286.  
  1287. =head2 seek
  1288.  
  1289.     $z->seek($position, $whence);
  1290.     seek($z, $position, $whence);
  1291.  
  1292. Provides a sub-set of the C<seek> functionality, with the restriction
  1293. that it is only legal to seek forward in the output file/buffer.
  1294. It is a fatal error to attempt to seek backward.
  1295.  
  1296. Empty parts of the file/buffer will have NULL (0x00) bytes written to them.
  1297.  
  1298. The C<$whence> parameter takes one the usual values, namely SEEK_SET,
  1299. SEEK_CUR or SEEK_END.
  1300.  
  1301. Returns 1 on success, 0 on failure.
  1302.  
  1303. =head2 binmode
  1304.  
  1305. Usage is
  1306.  
  1307.     $z->binmode
  1308.     binmode $z ;
  1309.  
  1310. This is a noop provided for completeness.
  1311.  
  1312. =head2 opened
  1313.  
  1314.     $z->opened()
  1315.  
  1316. Returns true if the object currently refers to a opened file/buffer. 
  1317.  
  1318. =head2 autoflush
  1319.  
  1320.     my $prev = $z->autoflush()
  1321.     my $prev = $z->autoflush(EXPR)
  1322.  
  1323. If the C<$z> object is associated with a file or a filehandle, this method
  1324. returns the current autoflush setting for the underlying filehandle. If
  1325. C<EXPR> is present, and is non-zero, it will enable flushing after every
  1326. write/print operation.
  1327.  
  1328. If C<$z> is associated with a buffer, this method has no effect and always
  1329. returns C<undef>.
  1330.  
  1331. B<Note> that the special variable C<$|> B<cannot> be used to set or
  1332. retrieve the autoflush setting.
  1333.  
  1334. =head2 input_line_number
  1335.  
  1336.     $z->input_line_number()
  1337.     $z->input_line_number(EXPR)
  1338.  
  1339. This method always returns C<undef> when compressing. 
  1340.  
  1341. =head2 fileno
  1342.  
  1343.     $z->fileno()
  1344.     fileno($z)
  1345.  
  1346. If the C<$z> object is associated with a file or a filehandle, C<fileno>
  1347. will return the underlying file descriptor. Once the C<close> method is
  1348. called C<fileno> will return C<undef>.
  1349.  
  1350. If the C<$z> object is is associated with a buffer, this method will return
  1351. C<undef>.
  1352.  
  1353. =head2 close
  1354.  
  1355.     $z->close() ;
  1356.     close $z ;
  1357.  
  1358. Flushes any pending compressed data and then closes the output file/buffer. 
  1359.  
  1360. For most versions of Perl this method will be automatically invoked if
  1361. the IO::Compress::Zip object is destroyed (either explicitly or by the
  1362. variable with the reference to the object going out of scope). The
  1363. exceptions are Perl versions 5.005 through 5.00504 and 5.8.0. In
  1364. these cases, the C<close> method will be called automatically, but
  1365. not until global destruction of all live objects when the program is
  1366. terminating.
  1367.  
  1368. Therefore, if you want your scripts to be able to run on all versions
  1369. of Perl, you should call C<close> explicitly and not rely on automatic
  1370. closing.
  1371.  
  1372. Returns true on success, otherwise 0.
  1373.  
  1374. If the C<AutoClose> option has been enabled when the IO::Compress::Zip
  1375. object was created, and the object is associated with a file, the
  1376. underlying file will also be closed.
  1377.  
  1378. =head2 newStream([OPTS])
  1379.  
  1380. Usage is
  1381.  
  1382.     $z->newStream( [OPTS] )
  1383.  
  1384. Closes the current compressed data stream and starts a new one.
  1385.  
  1386. OPTS consists of any of the the options that are available when creating
  1387. the C<$z> object.
  1388.  
  1389. See the L</"Constructor Options"> section for more details.
  1390.  
  1391. =head2 deflateParams
  1392.  
  1393. Usage is
  1394.  
  1395.     $z->deflateParams
  1396.  
  1397. TODO
  1398.  
  1399. =head1 Importing 
  1400.  
  1401. A number of symbolic constants are required by some methods in 
  1402. C<IO::Compress::Zip>. None are imported by default.
  1403.  
  1404. =over 5
  1405.  
  1406. =item :all
  1407.  
  1408. Imports C<zip>, C<$ZipError> and all symbolic
  1409. constants that can be used by C<IO::Compress::Zip>. Same as doing this
  1410.  
  1411.     use IO::Compress::Zip qw(zip $ZipError :constants) ;
  1412.  
  1413. =item :constants
  1414.  
  1415. Import all symbolic constants. Same as doing this
  1416.  
  1417.     use IO::Compress::Zip qw(:flush :level :strategy :zip_method) ;
  1418.  
  1419. =item :flush
  1420.  
  1421. These symbolic constants are used by the C<flush> method.
  1422.  
  1423.     Z_NO_FLUSH
  1424.     Z_PARTIAL_FLUSH
  1425.     Z_SYNC_FLUSH
  1426.     Z_FULL_FLUSH
  1427.     Z_FINISH
  1428.     Z_BLOCK
  1429.  
  1430. =item :level
  1431.  
  1432. These symbolic constants are used by the C<Level> option in the constructor.
  1433.  
  1434.     Z_NO_COMPRESSION
  1435.     Z_BEST_SPEED
  1436.     Z_BEST_COMPRESSION
  1437.     Z_DEFAULT_COMPRESSION
  1438.  
  1439. =item :strategy
  1440.  
  1441. These symbolic constants are used by the C<Strategy> option in the constructor.
  1442.  
  1443.     Z_FILTERED
  1444.     Z_HUFFMAN_ONLY
  1445.     Z_RLE
  1446.     Z_FIXED
  1447.     Z_DEFAULT_STRATEGY
  1448.  
  1449. =item :zip_method
  1450.  
  1451. These symbolic constants are used by the C<Method> option in the
  1452. constructor.
  1453.  
  1454.     ZIP_CM_STORE
  1455.     ZIP_CM_DEFLATE
  1456.     ZIP_CM_BZIP2
  1457.  
  1458.     
  1459.     
  1460.  
  1461. =back
  1462.  
  1463. =head1 EXAMPLES
  1464.  
  1465. =head2 Apache::GZip Revisited
  1466.  
  1467. See L<IO::Compress::Zlib::FAQ|IO::Compress::Zlib::FAQ/"Apache::GZip Revisited">
  1468.  
  1469.     
  1470.  
  1471. =head2 Working with Net::FTP
  1472.  
  1473. See L<IO::Compress::Zlib::FAQ|IO::Compress::Zlib::FAQ/"Compressed files and Net::FTP">
  1474.  
  1475. =head1 SEE ALSO
  1476.  
  1477. L<Compress::Zlib>, L<IO::Compress::Gzip>, L<IO::Uncompress::Gunzip>, L<IO::Compress::Deflate>, L<IO::Uncompress::Inflate>, L<IO::Compress::RawDeflate>, L<IO::Uncompress::RawInflate>, L<IO::Compress::Bzip2>, L<IO::Uncompress::Bunzip2>, L<IO::Compress::Lzop>, L<IO::Uncompress::UnLzop>, L<IO::Compress::Lzf>, L<IO::Uncompress::UnLzf>, L<IO::Uncompress::AnyInflate>, L<IO::Uncompress::AnyUncompress>
  1478.  
  1479. L<Compress::Zlib::FAQ|Compress::Zlib::FAQ>
  1480.  
  1481. L<File::GlobMapper|File::GlobMapper>, L<Archive::Zip|Archive::Zip>,
  1482. L<Archive::Tar|Archive::Tar>,
  1483. L<IO::Zlib|IO::Zlib>
  1484.  
  1485. For RFC 1950, 1951 and 1952 see 
  1486. F<http://www.faqs.org/rfcs/rfc1950.html>,
  1487. F<http://www.faqs.org/rfcs/rfc1951.html> and
  1488. F<http://www.faqs.org/rfcs/rfc1952.html>
  1489.  
  1490. The I<zlib> compression library was written by Jean-loup Gailly
  1491. F<gzip@prep.ai.mit.edu> and Mark Adler F<madler@alumni.caltech.edu>.
  1492.  
  1493. The primary site for the I<zlib> compression library is
  1494. F<http://www.zlib.org>.
  1495.  
  1496. The primary site for gzip is F<http://www.gzip.org>.
  1497.  
  1498. =head1 AUTHOR
  1499.  
  1500. This module was written by Paul Marquess, F<pmqs@cpan.org>. 
  1501.  
  1502. =head1 MODIFICATION HISTORY
  1503.  
  1504. See the Changes file.
  1505.  
  1506. =head1 COPYRIGHT AND LICENSE
  1507.  
  1508. Copyright (c) 2005-2008 Paul Marquess. All rights reserved.
  1509.  
  1510. This program is free software; you can redistribute it and/or
  1511. modify it under the same terms as Perl itself.
  1512.  
  1513.